package com.yang.controller;

import com.yang.entity.Address;
import com.yang.entity.OrderItem;
import com.yang.entity.Result;
import com.yang.entity.User;
import com.yang.service.AddressService;
import com.yang.service.UserService;
import com.yang.utils.AliOssUtil;
import com.yang.utils.JwtUtil;
import com.yang.utils.Md5Util;
import com.yang.utils.ThreadLocalUtil;
import jakarta.annotation.Resource;
import jakarta.validation.constraints.Pattern;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/user")
public class UserController {

    @Resource
    private UserService userService;

    //    引入redis
    @Resource
    private StringRedisTemplate stringRedisTemplate;

//    -------------------------------------以下为用户账号密码操作相关接口-------------------------------------

    /**
     * 登录功能，传入账号密码，返回相关用户信息
     *
     * @param userAccount  用户账号
     * @param userPassWord 用户密码
     * @author 杨鑫
     */
    @PostMapping("/login")
    public Result<String> login(
            // 限制用户输入的数据
            @Pattern(regexp = "^\\S{5,16}$") String userAccount,
            @Pattern(regexp = "^\\S{5,16}$") String userPassWord
    ) {
        System.out.println("user/login =====>");
        System.out.println("userAccount: " + userAccount
                + "userPassWord: " + userPassWord);
        // 查询用户是否存在
        User user = userService.findByUserAccount(userAccount);
        // 用户不存在提示
        if (user == null) return Result.error("用户不存在");

        // 验证密码是否正确
        if (Md5Util.getMD5String(userPassWord).equals(user.getUserPassword())) {
            // 登录成功
            Map<String, Object> claims = new HashMap<>();
            // 令牌的内容
            claims.put("userId", user.getUserId());
            claims.put("userAccount", user.getUserAccount());
            // 生成token令牌
            String token = JwtUtil.genToken(claims);
            // 保存token令牌到redis
            ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();
            operations.set(String.valueOf(user.getUserId()), token, 1, TimeUnit.HOURS);
            return Result.success(token);
        } else {
            // 密码错误
            return Result.error("密码错误");
        }
    }

    /**
     * 注册功能，传入用户信息，返回注册结果
     *
     * @param userAccount  用户注册账号信息
     * @param userPassWord 用户注册密码信息
     * @author 杨鑫
     */
    @PostMapping("/register")
    public Result register(
            // 限制用户输入的数据
            @Pattern(regexp = "^\\S{5,16}$") String userAccount,
            @Pattern(regexp = "^\\S{5,16}$") String userPassWord
    ) {
        System.out.println("user/register =====>");
        // 查询用户是否重复
        User user = userService.findByUserAccount(userAccount);
        if (user == null) {
            // 注册用户
            userService.register(userAccount, userPassWord);
            return Result.success();
        } else {
            // 用户已存在
            return Result.error("用户已存在");
        }
    }

    /**
     * 修改密码功能，传入用户账号、新密码、确认密码，返回修改结果
     *
     * @param newUserPassWord     新密码
     * @param confirmUserPassWord 重复确认的密码
     * @return
     */
    @PostMapping("/updatePassword")
    public Result updatePassword(
            // 限制用户输入的数据
            @Pattern(regexp = "^\\S{5,16}$") String oldUserPassWord,
            @Pattern(regexp = "^\\S{5,16}$") String newUserPassWord,
            @Pattern(regexp = "^\\S{5,16}$") String confirmUserPassWord
    ) {
        System.out.println("user/updatePassword =====>");
        // 验证输入的数据是否为空
        if (oldUserPassWord == null || newUserPassWord == null || confirmUserPassWord == null) {
            return Result.error("输入的数据为空");
        }
        // 获取用户信息
        Map<String, Object> claims = ThreadLocalUtil.get();
        String userAccount = (String) claims.get("userAccount");
        User user = userService.findByUserAccount(userAccount);
        // 验证密码是否正确
        if (!Md5Util.checkPassword(oldUserPassWord, user.getUserPassword())) {
            return Result.error("旧密码错误");
        }
        // 修改密码
        userService.updatePassword(userAccount, newUserPassWord);
        // 清除token
        stringRedisTemplate.delete(String.valueOf(user.getUserId()));
        return Result.success();
    }

    /**
     * 上传用户头像功能，传入文件，返回上传的url
     *
     * @param file
     * @return
     * @throws Exception
     */
    @PostMapping("/uploadAvatar")
    public Result uploadAvatar(MultipartFile file) throws Exception {
        System.out.println("user/uploadAvatar =====>");
        // 把文件存入到本地磁盘
        String originalFilename = file.getOriginalFilename();
        // 保证文件名称是唯一，防止文件覆盖
        String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));
        String url = AliOssUtil.uploadFile("user/" + fileName, file.getInputStream());
        // 保存文件路径到数据库
        Map<String, Object> claims = ThreadLocalUtil.get();
        Integer userId = (Integer) claims.get("userId");
        userService.updateAvatar(userId, url);
        return Result.success(url);
    }

    /**
     * 获取用户信息功能，返回用户信息
     *
     * @return
     */
    @GetMapping("/getUserInfo")
    public Result<User> getUserInfo() {
        System.out.println("user/getUserInfo =====>");
        // 获取用户信息
        Map<String, Object> claims = ThreadLocalUtil.get();
        String userAccount = (String) claims.get("userAccount");
        System.out.println("userAccount: " + userAccount);
        User user = userService.findByUserAccount(userAccount);
        return Result.success(user);
    }
}
